{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using QAOA to Solve the Max-Cut Problem\n",
    "\n",
    "Quantum machine learning typically involves building machine learning algorithms that are a hybrid of quantum and classical components - for example, you may have classical data prepared using classical preprocessing steps, encode that data into a quantum circuit, and use classical machine learning methods to optimize circuit parameters.\n",
    "\n",
    "In this tutorial, we'll use the quantum approximate optimization algorithm (QAOA) to find an approximate solution to the minimum vertex cover problem, as was done in this [Pennylane Tutorial](https://pennylane.ai/qml/demos/tutorial_qaoa_maxcut.html). We'll use Covalent to dispatch, organize, and track our computations every step of the way -- culminating in two workflows, each demonstrating a different way of using Covalent for easy experimentation.\n",
    "\n",
    "## Quantum Approximate Optimization Algorithm \n",
    "\n",
    "**QAOA** is an algoithm that can provide approximate solutions to combinatorial optimization problems -- problems aimed at optimmizing some cost function containing a finite set of variables. Many combinatorial optimization problems are NP-hard, making it computationally expensive to find an exact solution. Methods like QAOA get around that by instead finding approximate solutions. QAOA is a simple-to-implement algorithm that can function with little error mitigation and shallow circuit depths, so it is particularly well-suited to be run on NISQ (noisy intermediate-scale quantum) devices.\n",
    "\n",
    "QAOA problems consist of some bit string *z* and a clause *C*. Each item in the bit string is binary-valued, i.e. $z \\in \\{0,1\\}^n$, where *n* is the total number of bits. The clause $C(z)$ can be represented,\n",
    " \n",
    "$$ C_\\alpha= \n",
    "\\begin{array}{ll}\n",
    "    1, & \\textrm{ if z satisfies clause } C_\\alpha \\\\\n",
    "    0, & \\textrm{ otherwise.} \\\\\n",
    "\\end{array} $$\n",
    "\n",
    "The full clause satisfaction problem is treated as the summation over all clauses, $C(z) = \\sum_{\\alpha = 1}^{m} C_\\alpha (z)$, where *m* is the total number of clauses and the *z* in the summand depends on a subset of the bit string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Minimum Vertex Cover Problem\n",
    "\n",
    "The goal of this vertex cover problem is to find the *minimum* number of vertices needed in order to \"cover\" all edges in a graph. That is, we want to choose the fewest vertices such that every edge in the graph touches at least one chosen vertex. Determining the minimum vertex cover is an NP-complete problem, meaning that there is no known exact solution that can be found in polynomial time.\n",
    "\n",
    "In this problem, the bit string *z* consists of all vertices in the graph. A vertex is assigned a value of 1 if it is selected, and a value of 0 if it is not. \n",
    "\n",
    "<figure>\n",
    "  <img src=\"assets/min_vertex.png\" alt=\"min_vertex\" style=\"width:50%\">\n",
    "  <figcaption>Figure 1: A minimum vertex cover example, where chosen vertices and their associated edges are shown in blue. <i>(a)</i> No vertices are chosen, so no edge is covered. <i>(b)</i> Two vertices are chosen, but not all edges in the graph are covered. <i>(c)</i> Four vertices are chosen and all edges are covered, but this is not the minimum number of vertices to cover all edges. <i>(d)</i> Two vertices are chosen and all edges are covered.</figcaption>\n",
    "</figure>\n",
    "\n",
    "In our experiment below, we will use the Python *networkx* package to generate graphs, and minimize the number of chosen vertices."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Implementation \n",
    "\n",
    "We begin by installing and importing all necessary packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "covalent\n",
      "covalent-slurm-plugin==0.8.0\n",
      "matplotlib==3.4.3\n",
      "pennylane==0.26.0\n"
     ]
    }
   ],
   "source": [
    "with open(\"./requirements.txt\", \"r\") as file:\n",
    "    for line in file:\n",
    "        print(line.rstrip())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install required packages\n",
    "# !pip install -r ./requirements.txt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "from pennylane import qaoa\n",
    "from pennylane import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "# Covalent\n",
    "import covalent as ct\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "# Circuit Tasks\n",
    "\n",
    "To use Covalent, we need to organize our experiment into interdependent tasks, or Python functions. In the language of Covalent, these tasks are called electrons and specified using the `@ct.electron` decorator. Once we've written and decorated all of our electrons, we write a final function called a lattice, specified with the `@ct.lattice` decorator, that calls all the electrons in order and returns the final result.\n",
    "For steps that are more computationally heavy and would benefit from remote computational resources, we can call the executor to the desired electron, e.g. `@ct.electron(executor = GPU)`. \n",
    "\n",
    "We include the following functions to set up our quantum circuit, compute the cost given the quantum circuit, and update circuit parameters:\n",
    "\n",
    "- `make_graph`: Generates our graphs for a given number of nodes *n* (determined by the number of qubits) and probability *p* for edge creation at each node. Pennylane returns the QAOA cost and mixer Hamiltonians for the generated graph.\n",
    "\n",
    "- `get_circuit`: This electron includes two functions. `qaoa_layer` generates the cost and mixer layers given the Hamiltonians defined in the previous step and variational parameters *alpha* and *gamma*. `circuit` creates a quantum circuit from a Hadamard gate and the cost and mixer layers.\n",
    "\n",
    "- `make_cost_function`: Defines the simulator *dev* and computes the expectation value of the input circuit for a given cost Hamiltonian.\n",
    "\n",
    "- `get_random_initialization`: Generates two random values between 0 and $2\\pi$ from a uniform distribution.\n",
    "\n",
    "- `initialize_parameters`: Calls all previous functions to create initial values for the cost and mixer Hamiltonians, the resulting circuit, the cost function, the initial angles. Only the cost function and initial angles are returned.\n",
    "\n",
    "- `calculate_cost`: For an input optimizer, this function computes and returns the value of the cost function and progresses the optimizer by one step, updating the trainable parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "We can take a look at graphs generated using the networkx library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  (1.25) [Z0]\n",
      "+ (1.25) [Z1]\n",
      "+ (1.25) [Z2]\n",
      "+ (1.25) [Z3]\n",
      "+ (0.75) [Z0 Z1]\n",
      "+ (0.75) [Z0 Z2]\n",
      "+ (0.75) [Z0 Z3]\n",
      "+ (0.75) [Z1 Z2]\n",
      "+ (0.75) [Z1 Z3]\n",
      "+ (0.75) [Z2 Z3]   (1) [X0]\n",
      "+ (1) [X1]\n",
      "+ (1) [X2]\n",
      "+ (1) [X3]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph = nx.generators.random_graphs.gnp_random_graph(n=4, p=0.5)\n",
    "nx.draw(graph)\n",
    "cost_h, mixer_h = qaoa.min_vertex_cover(graph, constrained=False)\n",
    "print(cost_h, mixer_h)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can take a look at what our circuit will look like using the Pennylane qml draw function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ──H─╭ApproxTimeEvolution(0.75,1.25,1.25,0.75,1.25,0.75,1.25,0.75,0.75,0.75,0.00)\n",
      "1: ──H─├ApproxTimeEvolution(0.75,1.25,1.25,0.75,1.25,0.75,1.25,0.75,0.75,0.75,0.00)\n",
      "2: ──H─├ApproxTimeEvolution(0.75,1.25,1.25,0.75,1.25,0.75,1.25,0.75,0.75,0.75,0.00)\n",
      "3: ──H─╰ApproxTimeEvolution(0.75,1.25,1.25,0.75,1.25,0.75,1.25,0.75,0.75,0.75,0.00)\n",
      "\n",
      "──╭ApproxTimeEvolution(1.00,1.00,1.00,1.00,0.00)─┤ ╭<𝓗>\n",
      "──├ApproxTimeEvolution(1.00,1.00,1.00,1.00,0.00)─┤ ├<𝓗>\n",
      "──├ApproxTimeEvolution(1.00,1.00,1.00,1.00,0.00)─┤ ├<𝓗>\n",
      "──╰ApproxTimeEvolution(1.00,1.00,1.00,1.00,0.00)─┤ ╰<𝓗>\n"
     ]
    }
   ],
   "source": [
    "cost_h, mixer_h = qaoa.min_vertex_cover(graph, constrained=False)\n",
    "qubits = 4\n",
    "qaoa.cost_layer(0, cost_h)\n",
    "qaoa.mixer_layer(0, mixer_h)\n",
    "\n",
    "dev = qml.device(\"lightning.qubit\", wires=qubits)\n",
    "\n",
    "\n",
    "@qml.qnode(dev)\n",
    "def example_circuit():\n",
    "    qml.Hadamard(wires=0)\n",
    "    qml.Hadamard(wires=1)\n",
    "    qml.Hadamard(wires=2)\n",
    "    qml.Hadamard(wires=3)\n",
    "    qaoa.cost_layer(0, cost_h)\n",
    "    qaoa.mixer_layer(0, mixer_h)\n",
    "    return qml.expval(cost_h)\n",
    "\n",
    "\n",
    "print(qml.draw(example_circuit)())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "@ct.electron\n",
    "def make_graph(qubits, prob):\n",
    "    graph = nx.generators.random_graphs.gnp_random_graph(n=qubits, p=prob)\n",
    "    cost_h, mixer_h = qaoa.min_vertex_cover(graph, constrained=False)\n",
    "    return cost_h, mixer_h\n",
    "\n",
    "\n",
    "@ct.electron\n",
    "def get_circuit(cost_h, mixer_h):\n",
    "    def qaoa_layer(gamma, alpha):\n",
    "        qaoa.cost_layer(gamma, cost_h)\n",
    "        qaoa.mixer_layer(alpha, mixer_h)\n",
    "\n",
    "    def circuit(params, wires, **kwargs):\n",
    "        depth = params.shape[1]\n",
    "        for w in range(wires):\n",
    "            qml.Hadamard(wires=w)\n",
    "        qml.layer(qaoa_layer, depth, params[0], params[1])\n",
    "\n",
    "    return circuit\n",
    "\n",
    "\n",
    "@ct.electron\n",
    "def make_cost_function(circuit, cost_h, qubits):\n",
    "    dev = qml.device(\"lightning.qubit\", wires=qubits)\n",
    "\n",
    "    @qml.qnode(dev)\n",
    "    def cost_function(params):\n",
    "        circuit(params, wires=qubits)\n",
    "        return qml.expval(cost_h)\n",
    "\n",
    "    return cost_function\n",
    "\n",
    "\n",
    "@ct.electron\n",
    "def get_random_initialization(p=1):\n",
    "    return np.random.uniform(0, 2 * np.pi, (2, p), requires_grad=True)\n",
    "\n",
    "\n",
    "@ct.electron\n",
    "def initialize_parameters(p=1, qubits=2, prob=0.3):\n",
    "    cost_h, mixer_h = make_graph(qubits=qubits, prob=prob)\n",
    "    circuit = get_circuit(cost_h, mixer_h)\n",
    "    cost_function = make_cost_function(circuit, cost_h, qubits)\n",
    "    initial_angles = get_random_initialization(p=p)\n",
    "    print(initial_angles)\n",
    "    return cost_function, initial_angles\n",
    "\n",
    "\n",
    "@ct.electron\n",
    "def calculate_cost(cost_function, params, optimizer):\n",
    "    params, loss = optimizer.step_and_cost(cost_function, params)\n",
    "    return optimizer, params, loss\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final two functions in our workflow contain the optimization and post-processing step:\n",
    "\n",
    "- `optimize_electron`: initializes parameters, iterates through the optimization process, and returns the loss of each iteration\n",
    "- `collect_and_mean`: a simple electron to return the mean value of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "@ct.electron\n",
    "def optimize_electron(\n",
    "    cost_function, init_angles, optimizer=qml.GradientDescentOptimizer(), iterations=10\n",
    "):\n",
    "    loss_history = []\n",
    "    params = init_angles\n",
    "    for _ in range(iterations):\n",
    "        optimizer, params, loss = calculate_cost(\n",
    "            cost_function=cost_function, params=params, optimizer=optimizer\n",
    "        )\n",
    "        loss_history.append(loss)\n",
    "    return loss_history\n",
    "\n",
    "\n",
    "@ct.electron\n",
    "def collect_and_mean(array):\n",
    "    return np.mean(array, axis=0)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The run_exp Workflow\n",
    "\n",
    "Running this lattice makes the most sense if you're uninterested in saving your intermediate optimization steps, as opposed to the `optimize` lattice, which will come later. In this case, the optimization is performed *within* the `optimize_electron` task, so only the final output of that electron - the loss history - is saved. This is ideal for running simulations.\n",
    "\n",
    "As the number of iterations in `optimize_electron` increases, the runtime will get long, so this particular electron is sent to a remote device for faster computation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "@ct.lattice\n",
    "def run_exp(p=1, qubits=2, prob=0.3, optimizers=[qml.GradientDescentOptimizer()], iterations=10):\n",
    "    compare_optimizers = []\n",
    "    tmp = []\n",
    "    cost_function, init_angles = initialize_parameters(p=p, qubits=qubits, prob=prob)\n",
    "    for optimizer in optimizers:\n",
    "        loss_history = optimize_electron(\n",
    "            cost_function=cost_function,\n",
    "            init_angles=init_angles,\n",
    "            optimizer=optimizer,\n",
    "            iterations=iterations,\n",
    "        )\n",
    "        tmp.append(loss_history)\n",
    "    compare_optimizers.append(tmp)\n",
    "    return collect_and_mean(compare_optimizers)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize the `run_exp` workflow on the Covalent UI once we've dispatched it. It automatically generates a directed acyclic graph, or DAG, showing the relationships between all electrons in the workflow.\n",
    "\n",
    "![](assets/run_exp_dag.png)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Dispatching the Workflow\n",
    "\n",
    "Since we've imported `covalent` as `ct`, we can use the dispatch syntax in order to dispatch our workflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "id = ct.dispatch(run_exp)(\n",
    "    p=1, qubits=2, prob=0.3, optimizers=[qml.GradientDescentOptimizer()], iterations=100\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see our results below - we retrieve our results using the `ct.get_result` method, specifying the dispatch id set above and letting wait=True to wait for the workflow to finish. The `run_exp` workflow is set up to take a list of optimizers and compute the mean loss value, but when we dispatched our workflow we only included the Pennylane GradientDescentOptimizer.\n",
    "\n",
    "We plot the loss values as a function of iterations - as expected, with more iterations the loss decreases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEGCAYAAAB7DNKzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAArkElEQVR4nO3deXgV9dn/8fedHULY9zVBQCBAAoRFEVxxq4hL3a2oj6JV27q1tfVX2/L4uNS2T221KhUXfLRgtYBWlIobm4KJLLKIbBECsgsEQiDL/fvjHNKISQiQZJKcz+u6zpUzM98zcw8TziezfcfcHRERkfJEBV2AiIjUbgoKERGpkIJCREQqpKAQEZEKKShERKRCMUEXUB1atmzpycnJQZchIlJnZGVlbXf3VmVNq5dBkZycTGZmZtBliIjUGWb2VXnTdOhJREQqpKAQEZEKKShERKRC9fIchUiQCgoKyMnJIT8/P+hSRL4jISGBjh07EhsbW+nPKChEqlhOTg5JSUkkJydjZkGXI1LC3dmxYwc5OTmkpKRU+nM69CRSxfLz82nRooVCQmodM6NFixZHvberoBCpBgoJqa2O5XdTQRHm7vzlvVUs27Q76FJERGoVBUXYrrwC/r5gPVeO/4TM7J1BlyNy3LZs2cLVV19N165dGThwICeddBJTpkw55vn95je/4fe//z0ADzzwADNnzjym+SxatIjp06eXDL/wwgu0atWK/v370717d8455xzmzZt3zHVWhcNrBJg6dSr9+vWjV69e9O3bl6lTpx5xPh9++OG31uXpp59m4sSJR1XLySeffFTtq4OCIqxZYhz/+OHJtGoUz7UT5vPhyq1BlyRyzNydiy66iBEjRrB27VqysrKYNGkSOTk532pXWFh4TPMfN24cZ5111jF9tqwv4SuuuIKFCxeyatUq7rvvPi655BJWrFhxTPOvCofXuHjxYu69916mTZvGihUreOONN7j33ntZsmRJhfM5PChuvfVWrrvuuqOqpSpCs6io6Phm4O717jVw4EA/Vtty8/28P83ybr98y6cuzDnm+UjkWr58edAl+MyZM33EiBFlTnv++ed91KhRfvrpp/uIESM8NzfXzzjjDO/fv7/36dPHp06dWtL2wQcf9O7du/uwYcP8yiuv9Mcee8zd3ceMGeP/+Mc/3N09MzPTR4wY4QMGDPCzzz7bN23a5O7up556qv/sZz/zQYMGeffu3X3WrFl+4MAB79Spk7ds2dLT0tJ80qRJ/vzzz/vtt9/+rRp/9atf+Z133unu7qtXr/ZzzjnHBwwY4KeccoqvWLHC3d1fffVVT01N9X79+vnw4cPd3b2wsNDvueceT01N9b59+/qf//znKqnx2muv9QkTJnyrxmeffdavvfbakvn8+Mc/9rS0NE9NTfX58+f7unXrvE2bNt6+fXtPS0vzWbNm+a9//euSf8NTTz3V77zzTh84cKD37NnTFyxY4BdffLF369bN77///pLlJCYmlvybpKWleVpamrdv396vv/56d3d/6aWXfNCgQZ6WluZjx471wsLCks/dfffd3q9fP589e/a3ai/rdxTI9HK+U3V57GFaNopn0i1DuenFTH4yaRGrt+7lrrN6EBWlk5Ny9H775jKWb9pTpfPs3b4xvx6VWmGbZcuWMWDAgHKnf/bZZyxZsoTmzZtTWFjIlClTaNy4Mdu3b2fo0KFceOGFfPbZZ0yaNIlFixZRWFjIgAEDGDhw4LfmU1BQwI9+9COmTZtGq1atmDx5Mvfffz/PPfccENpjWbBgAdOnT+e3v/0tM2fOZNy4cWRmZvLEE08AoUNPhxswYADPPPMMAGPHjuXpp5+me/fuzJ8/n9tuu43333+fcePGMWPGDDp06MCuXbsAGD9+PNnZ2SxatIiYmBh27txZJTU++uij3Hvvvd+qMSMjgyeffLJkOC8vj0WLFjFr1ixuvPFGli5dyq233kqjRo1KPvvee+99ax5xcXFkZmby+OOPM3r0aLKysmjevDknnHACd911Fy1atChpO27cOMaNG8euXbsYPnw4d9xxBytWrGDy5MnMnTuX2NhYbrvtNl5++WWuu+469u3bx5AhQ/jDH/5Q7u9BZSkoytA4IZb/+68h/GrqUv7y/mq+3JLLHy9PJzFe/1xSN91+++3MmTOHuLg4br/9dkaOHEnz5s2B0FGFX/7yl8yaNYuoqCg2btzIli1bmD17NhdffDENGzYE4MILL/zOfFeuXMnSpUsZOXIkEDrE0a5du5Lpl1xyCQADBw4kOzu70vWG/sCFvXv3Mm/ePC677LKSaQcOHABg2LBhXH/99Vx++eUly5k5cya33norMTGh/6vNmzdn6dKl1VLj4a666ioARowYwZ49e0rCqyKH/k379u1LampqSV1du3Zlw4YN3woKCP27XHvttdx9990MHDiQJ554gqysLAYNGgTA/v37ad26NQDR0dFceumlx7w+pembrxxxMVE8cmlfTmybxINvLWf0k3N54ur+9GzbOOjSpA450l/+1SU1NZXXX3+9ZPjJJ59k+/btZGRkAJCYmFgy7eWXX2bbtm1kZWURGxtLcnJypa+zd3dSU1P5+OOPy5weHx8PhL60juZ8yMKFC+nVqxfFxcU0bdqURYsWfafN008/zfz583nrrbcYOHAgWVlZ1VZj7969ycrKIi0trWRcVlYWqan/2b6HX3ZamctQDy07Kiqq5P2h4bJq+c1vfkPHjh254YYbStZtzJgxPPzww99pm5CQQHR09BFrqAydzK6AmXHjKSlMvHEIu/IKuPCJubz0yVclf+2I1FZnnHEG+fn5PPXUUyXj8vLyymy7e/duWrduTWxsLB988AFffRXqbXrEiBFMnTqV/fv3k5uby5tvvvmdz5544ols27at5Eu4oKCAZcuWVVhbUlISubm55U7/6KOPGD9+PDfffDONGzcmJSWFf/zjH0Doi3Hx4sUArFmzhiFDhjBu3DhatWrFhg0bGDlyJM8880zJl+zOnTurpMZ7772Xhx9+uGSPIzs7m4ceeoh77rmnpM3kyZMBmDNnDk2aNKFJkyZHXNej8eabbzJz5kz+/Oc/l4w788wzee2119i6dWvJ+h7aflVJQVEJp3Rvyds/Gc7Qri341dSl3Dwxky171I+P1F5mxtSpU/noo49ISUlh8ODBjBkzhkcfffQ7ba+55hoyMzPp27cvEydOpGfPnkDoPMEVV1xBWloa5513XsnhjdLi4uJ47bXX+PnPf05aWhrp6elHvErn9NNPZ/ny5aSnp5d8uU6ePJn09HR69OjBQw89xOuvv06vXr2A0B7PhAkTSEtLIzU1lWnTpgHw05/+lL59+9KnTx9OPvlk0tLSuOmmm+jcuTP9+vUjLS2NV155pUpqTE9P59FHH2XUqFH07NmTUaNG8bvf/Y709PSSzyQkJNC/f39uvfVWJkyYAMCoUaOYMmUK6enpzJ49u8JlHskf//hHNm7cyODBg0lPT+eBBx6gd+/ePPjgg5x99tn069ePkSNH8vXXXx/Xcspi9fGv44yMDK+OBxcVFzvPzV3HYzNWEhcdxS/O78WVgzrpRLd8y4oVK0q+5CQynHbaafz+978vObRX25X1O2pmWe5e5gpoj+IoREUZNw3vyow7R9CnQxN+OeVzrhz/CUs36m5uEam/FBTHILllIq/cPIRHL+3L6m17GfXEHH7+2hK25upwlEgk+vDDD+vM3sSxUFAcIzPjikGd+eDe07jplBT+uTCHU3/3IY+8/QU79x0MujwJWH08pCv1w7H8bioojlOTBrHc/73evHvXqZyT2oZnZq1h+KPv87t3vtAeRoRKSEhgx44dCgupdTz8PIqEhISj+pxOZlexVVty+dN7q5j++dfERkVxyYAO3DQ8hW6tkwKpR2qennAntVl5T7ir6GS2gqKarNu+jwlz1vKPzBwOFBZz8gktuGZIF85ObUNstHbkRKR2UVAEaMfeA0z6dAOvzF/Pxl37adkonksGdODSAR05sa32MkSkdlBQ1AJFxc5HX27l7ws28MEXWyksdvp2aMLo9PaMSmtPm8ZHd8xQRKQq1dqgMLNzgceBaOBZd3/ksOnxwERgILADuMLds48039oYFKXt2HuAaYs28c+FOSzduAczGJLSnO/1bcc5fdrSOkmhISI1q1YGhZlFA18CI4Ec4FPgKndfXqrNbUA/d7/VzK4ELnb3K44079oeFKWt2baXNxdv4s3Fm1izbR9mMKhLc87p05ZzUtvQsVnDoEsUkQhQW4PiJOA37n5OePgXAO7+cKk2M8JtPjazGGAz0MqPUHRdCopD3J1VW/cy/fOvefvzzazcEupIrE+HxpzTuy1np7alR5tGx/RgdBGRI6koKILsZrwDsKHUcA4wpLw27l5oZruBFsD2w2dmZmOBsQCdO3eujnqrlZnRo00SPdokcedZPcjevo8ZyzYzY9lm/vDul/zh3S9JbtGQs1NDexr9OzVTH1MiUiPqzfMo3H08MB5CexQBl3PcklsmcsupJ3DLqSewdU8+767YwoxlW3h+7jrGz1pLq6R4zkltw/l92jE4pTkxuuRWRKpJkEGxEehUarhjeFxZbXLCh56aEDqpHVFaN07gmiFduGZIF/bkF/DBF1uZsWwzr2dt5P8+WU/zxDjOSW3DqLT2DElpQbT2NESkCgUZFJ8C3c0shVAgXAlcfVibN4AxwMfA94H3j3R+or5rnBDL6PQOjE7vwP6DRXz05Vbe+nwz0xZt4u8LNtA6KZ5Rae25dEBHerfX0/hE5PgFfXns+cCfCF0e+5y7/4+ZjQMy3f0NM0sAXgL6AzuBK9197ZHmWxdPZh+vvIOFvP/FVt5YtIkPVm6loMjp1a4x3x/YkUsHdKBpw7igSxSRWqxWXvVUnSIxKEr7Zt9B3lyyidezclics5v4mCi+168d1w7twoDOzYIuT0RqIQVFBFu+aQ+vLPiKqQs3sfdAIf07N+WmU7pyTmobnQAXkRIKCmHfgUJe/yyH5+asI3tHHp2aN+C207px6YCOxMUoMEQinYJCShQVOzNXbOGvH65h8YZddGjagNtOP4HLMzqpV1uRCKagkO9wd2at2s7jM7/ks/W76NoqkfvO7cnI3m1097dIBKooKPQnZIQyM07t0YrXf3gyz16XgQFjX8riivGfsHJzbtDliUgtoqCIcGbGWb3bMOPOEfz3RX1YtSWX7/15No+8/QX7DxYFXZ6I1AIKCgEgJjqKHwztwnv3nMbF/Tvw9EdrGPm/H/HJ2oi7EV5EDqOgkG9pnhjHY5elMWnsUGKijKv+9gkPT1/BgULtXYhEKgWFlGlo1xa89ePhXDmoM8/MWstFT85jzba9QZclIgFQUEi5EuNjePiSvkwYk8GWPfmMfmIuM5ZtDrosEalhCgo5ojN7teHNH53CCa0SueWlLH73zhcUFde/y6pFpGwKCqmUDk0bMPmWk7hqcCf++uEafvh/WeQX6LyFSCRQUEilJcRG8/Al/fj1qN68u2ILV//tE3buOxh0WSJSzRQUctRuGJbCU9cMYNmmPXz/qXls2JkXdEkiUo0UFHJMzu3TjpdvGsKOfQe5cvwnrN+hsBCprxQUcswykpvz8k1D2HewkCvHf8xXO/YFXZKIVAMFhRyXPh2a8MpNQ9lfUMQVz3xC9naFhUh9o6CQ49a7fWNeuXkoBwqL+MFz89mamx90SSJShRQUUiV6tWvM8zcMZnvuQa5/7lNy8wuCLklEqoiCQqpMeqemPHXtAL7cksstL2WpfyiRekJBIVXqtBNb89hl/Zi3Zgf3vf459fHBWCKRJiboAqT+ubh/R3J27ucP735J73aNuXlE16BLEpHjoD0KqRZ3nNGN8/u25eG3V/DRl9uCLkdEjoOCQqqFmfHY99Po0SaJH73yGet02axInaWgkGqTGB/D367LIDrK1ImgSB2moJBq1al5Q/54eTpfbM7loekrgi5HRI6BgkKq3ek9W3PTKSlM/Pgr3lmqBx+J1DUKCqkRPzu3J307NOFnry0m5xt1IChSlygopEbExUTxl6v6U+xw9+TFFOsJeSJ1hoJCakxyy0QeGNWbBdk7efHj7KDLEZFKUlBIjbpsYEdOP7EVj77zhXqaFakjFBRSo8yMhy/pR2x0FD97bYkOQYnUAQoKqXFtmyTwqwt0CEqkrlBQSCAuG9iR005sxWMzVvL17v1BlyMiFVBQSCDMjP8e3YeiYmfcm8uDLkdEKhBIUJhZczN718xWhX82K6ddkZktCr/eqOk6pXp1at6QH53RjbeXbuaDlVuDLkdEyhHUHsV9wHvu3h14Lzxclv3unh5+XVhz5UlNuXlEV7q2SuTX05apLyiRWiqooBgNvBh+/yJwUUB1SMDiY6J5cHQf1u/M468frA66HBEpQ1BB0cbdvw6/3wy0KaddgpllmtknZnZRzZQmNe3kbi0Znd6ep2etVfceIrVQtQWFmc00s6VlvEaXbuehZ2WWdzF9F3fPAK4G/mRmJ1SwvLHhUMnctk0Pyqlrfn5uT6IMHn1nZdCliMhhqi0o3P0sd+9TxmsasMXM2gGEf5Z5JtPdN4Z/rgU+BPpXsLzx7p7h7hmtWrWq8vWR6tW+aQPGDu/Km4s3kfXVN0GXIyKlBHXo6Q1gTPj9GGDa4Q3MrJmZxYfftwSGAbqOsh675dQTaJ0Uz4NvLSe0oykitUFQQfEIMNLMVgFnhYcxswwzezbcpheQaWaLgQ+AR9xdQVGPJcbHcO85J7Jw/S7eXPL1kT8gIjXC6uNfbhkZGZ6ZmRl0GXIMioqdUX+Zw+79Bbx/76nEx0QHXZJIRDCzrPA54e/QndlSq0RHGb84vycbd+3nlfnrgy5HRFBQSC10SreWnNS1BU9+sJp9BwqDLkck4ikopNYxM3567ols33uQ5+euC7ockYinoJBaaUDnZpzVqw3PzFrLrryDQZcjEtEUFFJr3XtOD/YeKOTpj9YGXYpIRFNQSK3Vs21jRqe154V569iWeyDockQiloJCarWfnNWDg4XF/G229ipEgqKgkFotpWUio9M78NLHX7Fjr/YqRIKgoJBa7/bTu5FfWMTfZusKKJEgKCik1uvWuhGj+rVn4sfZ7NynK6BEapqCQuqEH5/Zjf0FRUyYo3MVIjVNQSF1QrfWSXyvbztenPcVu/MKgi5HJKIoKKTOuOOMbuw9UMjEj7ODLkUkoigopM7o2bYxZ/ZszfPzstl/sCjockQihoJC6pQfnnYCO/cdZPKn6llWpKYoKKROyUhuzqDkZvxt9joKioqDLkckIigopM754WknsHHXft5YtCnoUkQigoJC6pzTT2xNz7ZJPPXRGoqL698TGkVqGwWF1Dlmxg9PO4HVW/fy/hdbgy5HpN5TUEiddH7fdrRvkqDOAkVqgIJC6qTY6ChuPCWF+et2snjDrqDLEanXKhUUZvZSZcaJ1KQrBnUiKT5GexUi1ayyexSppQfMLBoYWPXliFReUkIsVw/pzPTPv2bDzrygyxGptyoMCjP7hZnlAv3MbE/4lQtsBabVSIUiFbh+WDJRZjw/NzvoUkTqrQqDwt0fdvck4DF3bxx+Jbl7C3f/RQ3VKFKudk0aMCqtPZM+Xa/OAkWqSWUPPf3LzBIBzOxaM/ujmXWpxrpEKu2m4SnkHSxikrr1EKkWlQ2Kp4A8M0sD7gHWABOrrSqRo5DavglDuzbnxXnZFKpbD5EqV9mgKHR3B0YDT7j7k0BS9ZUlcnT+65SubNqdzzvLNgddiki9U9mgyDWzXwA/AN4ysyggtvrKEjk6Z/ZsTZcWDZkwR8/VFqlqlQ2KK4ADwI3uvhnoCDxWbVWJHKWoKOOGk5NZuH4Xn63/JuhyROqVSgVFOBxeBpqY2QVAvrvrHIXUKpdldCIpIYbntFchUqUqe2f25cAC4DLgcmC+mX2/OgsTOVqJ8TFcNbgzby/dzMZd+4MuR6TeqOyhp/uBQe4+xt2vAwYDv6q+skSOzZiTk3F3PVdbpApVNiii3L10f847juKzIjWmQ9MGnJPalkkLNpB3sDDockTqhcp+2b9jZjPM7Hozux54C5hefWWJHLsbhqWwe38BUxZuDLoUkXrhSH09dTOzYe7+U+AZoF/49TEwvgbqEzlqg5Kbkdq+MS/MzSZ0+4+IHI8j7VH8CdgD4O7/dPe73f1uYEp42jExs8vMbJmZFZtZRgXtzjWzlWa22szuO9blSWQxM24YlsKqrXuZu3pH0OWI1HlHCoo27v754SPD45KPY7lLgUuAWeU1CHdl/iRwHtAbuMrMeh/HMiWCXNCvHS0S43h+ri6VFTleRwqKphVMa3CsC3X3Fe6+8gjNBgOr3X2tux8EJhHqQkTkiBJio7lmSGfeX7mVddv3BV2OSJ12pKDINLObDx9pZjcBWdVTUokOwIZSwznhcWUys7Fmlmlmmdu2bavm0qQuuHZoF2KijBfnZQddikidFnOE6XcCU8zsGv4TDBlAHHBxRR80s5lA2zIm3e/uVf7QI3cfT/gEe0ZGhs5gCq0bJ/C9vu14LSuHe87uQVKCuicTORYVBoW7bwFONrPTgT7h0W+5+/tHmrG7n3WctW0EOpUa7hgeJ1JpNwxLYeqiTbyWlcMNw1KCLkekTjrSHgUA7v4B8EE113K4T4HuZpZCKCCuBK6u4Rqkjkvr1JT+nZvy4rxsxpyUTFSUBV2SSJ0TyN3VZnaxmeUAJxHqtnxGeHx7M5sO4O6FwB3ADGAF8Kq7LwuiXqnbbhiWQvaOPD78cuuRG4vId1Rqj6KqufsUQvdiHD5+E3B+qeHp6A5wOU7n9WlL28YJPD83mzN6tgm6HJE6R/01Sb0XGx3FD07qwuxV21m1JTfockTqHAWFRISrBncmPiaK53WprMhRU1BIRGieGMdF6R3452c57Mo7GHQ5InWKgkIixg2nJJNfUMzfF2w4cmMRKaGgkIjRs21jhnVrwcSPsykoKg66HJE6Q0EhEeXGYSl8vTufd5ZuDroUkTpDQSER5fQTW5PcoqF6lRU5CgoKiShRUcb1Jyfz2fpdLFz/TdDliNQJCgqJON/P6ERSfAwT5mivQqQyFBQScRrFx3DVkM68vXQzG3ftD7ockVpPQSERaczJyQC8oHMVIkekoJCI1KFpA77Xtx2TFmwgN78g6HJEajUFhUSsm4ankHugkMmf6gY8kYooKCRi9evYlMHJzXl+bjaFugFPpFwKColoNw1PYeOu/bytG/BEyqWgkIh2Zq82JLdoyN9mr8Vdj1oXKYuCQiJadJRx84iuLMnZzcdrdwRdjkitpKCQiHfpgI60bBTH0x+tDboUkVpJQSERLyE2mhuGpTDry20s37Qn6HJEah0FhQhw7ZAuJMZFM37WmqBLEal1FBQiQJOGsVw1uDNvLvmaDTvzgi5HpFZRUIiE/dfwFAzUWaDIYRQUImHtmjTg4v4d+PuC9WzLPRB0OSK1hoJCpJTbTu9GQVExz87WFVAihygoREpJaZnIqLT2vPTJV3yz72DQ5YjUCgoKkcPcfno38g4W8Zy6IBcBFBQi39GjTRLnprblhbnZ7N6vLshFFBQiZbjjjG7kHihk4rzsoEsRCZyCQqQMfTo04cyerXl2zjr26MFGEuEUFCLluGtkD3bvL2DCbJ2rkMimoBApR58OTTivT1smzFmnK6AkoikoRCpw18ge7DtYyDOzdF+FRC4FhUgFerRJYnRae16Yt46tuflBlyMSCAWFyBH85KweFBQ5f/1APctKZFJQiBxBSstELhvYkZfnf8X6HepZViJPIEFhZpeZ2TIzKzazjAraZZvZ52a2yMwya7JGkdLuGtmDmKgofjfji6BLEalxQe1RLAUuAWZVou3p7p7u7uUGikh1a9M4gZtHdOVfS75m4fpvgi5HpEYFEhTuvsLdVwaxbJFjdcuIrrRsFM9D01fg7kGXI1Jjavs5Cgf+bWZZZja2ooZmNtbMMs0sc9u2bTVUnkSSxPgY7h7Zg0+zv2HGsi1BlyNSY6otKMxsppktLeM1+ihmc4q7DwDOA243sxHlNXT38e6e4e4ZrVq1Ou76RcpyeUZHurduxCNvr+BAYVHQ5YjUiGoLCnc/y937lPGadhTz2Bj+uRWYAgyurnpFKiMmOopfXdCb7B15PKuuPSRC1NpDT2aWaGZJh94DZxM6CS4SqBE9WnFen7b85f1V5Hyjy2Wl/gvq8tiLzSwHOAl4y8xmhMe3N7Pp4WZtgDlmthhYALzl7u8EUa/I4f7fBb0xjP/+1/KgSxGpdjFBLNTdpxA6lHT4+E3A+eH3a4G0Gi5NpFI6NG3AHWd047EZK/lw5VZOO7F10CWJVJtae+hJpLa7aXgKXVsm8ps3lpFfoBPbUn8pKESOUXxMNP99UR+yd+Txv+9+GXQ5ItVGQSFyHIZ1a8lVgzvxt9lrdce21FsKCpHj9Ivze9GmcQI/e22J7q2QeklBIXKcGifE8tAlfVm1dS9PvL866HJEqpyCQqQKnH5iay4d0JG/friGz3QISuoZBYVIFXlgVG/aNUngJ5MWsie/IOhyRKqMgkKkijRpEMvjV/Zn06587p+yVD3MSr2hoBCpQgO7NOPukT14c/EmXsvKCbockSqhoBCpYreeegIndW3BA9OWsXJzbtDliBw3BYVIFYuOMv50ZTpJCTHcPDGTXXkHgy5J5LgoKESqQZvGCTz9g4Fs3p3PHa8spLCoOOiSRI6ZgkKkmgzo3IwHL+rDnNXbefjtL4IuR+SYBdJ7rEikuHxQJ5Zt2s2EOetIbpnID4Z2CbokkaOmoBCpZr+6oDc53+zngWlLaZEYx/l92wVdkshR0aEnkWoWEx3FE1cPYGDnZtw5aRHzVm8PuiSRo6KgEKkBDeKimTBmEMktGzL2pSz1NCt1ioJCpIY0aRjLxBuH0KJRHD+YsIBPs3cGXZJIpSgoRGpQ2yYJTB57Eq0bxzPmuQXMW6PDUFL7KShEaljbJglMGjuUDk0bcMPznzJz+ZagSxKpkIJCJACtk0JhcWLbJG5+KZPn5qxTJ4JSaykoRALSolE8k8YO5ezebRj3r+X8+o1luoNbaiUFhUiAGsbF8NQ1Axk7oisTP/6Ka56dz5Y9+UGXJfItCgqRgEVFGb88vxd/vDyNJTm7Of/x2cz6clvQZYmUUFCI1BKXDOjImz8aRotGcYx5fgEP/ms5+w8WBV2WiIJCpDbp1jqJabefwtWDO/PsnHWc+/gsPl6zI+iyJMIpKERqmQZx0fzPxX35+81DAbjqb59wz6uLde5CAqOgEKmlTjqhBe/8ZAS3nnoCby7exGmPfcjjM1fpcJTUOKuP125nZGR4ZmZm0GWIVJn1O/J45J0VTP98My0bxXHz8K5cO7QLifHqAFqqhplluXtGmdMUFCJ1R2b2Th5/bxWzV22nWcNYrjspmWuGdKZ144SgS5M6TkEhUs8sXP8NT7y/mve+2EpMlHFe33ZcM6Qzg5ObExVlQZcndZCCQqSeyt6+j5c++YpXMzeQm19Ih6YNuKh/ey5M60CPNo0wU2hI5SgoROq5vIOF/HvZFqYs3MjsVdsodujSoiFn927Dmb3aMKBzM+JidO2KlE9BIRJBtubm8+9lW3h3+RbmrdlOQZHTIDaaIV2bc/IJLchIbk5q+8bEx0QHXarUIgoKkQiVm1/Ax2t2MHf1duas3s6abfsAiIuJom+HJvRp35jUDk1Ibd+YE1o1IiFW4RGpFBQiAoT2Nj77ahefrf+Gheu/YfmmPewL35cRZdC5eUO6tU4ipWVDurRIpEuLhnRs1pB2TRIUIvVcRUERyEXYZvYYMAo4CKwBbnD3XWW0Oxd4HIgGnnX3R2qyTpH6pnVSAuf2acu5fdoCUFzsZO/Yx/Kv9/Dllr2s3prLqi17mb1qGwcKv93leaukeNo2TqBN43haJSXQKimelo3iaJEYT7PEWJo2iKNZYixNGsTSIDZaJ9LrkUD2KMzsbOB9dy80s0cB3P3nh7WJBr4ERgI5wKfAVe6+/Ejz1x6FyPEpLna25OaTvT2PTbv2s3HXfjbt2s+WPfls2XOALXvy2Zl3kPK+PmKijMYNYmkUH1PySoyPpmF8DA1jo2kYF01C7H9e8TFRJT/jYqKIjY4iPvwzNtqIjYkiNiqKmGgjNtqIiYoiOsqIiTaio4xoC42LioLoKCPKQq/QexRalVDr9ijc/d+lBj8Bvl9Gs8HAandfC2Bmk4DRwBGDQkSOT1SU0a5JA9o1aVBum6Ji55u8g2zfe4Bv9hWwK+8g3+QVsCe/gD37Qz/35hey90AhufmFbN97kLydeeQdLCLvYBH5BUXf2WupLmaEgsMMLHSYLcoMI/wzHCbhyaH34c9B6fFgfLtd6WUcGgx9+j/jS96XjCvd4vBiy3xbxjp9d2rzhnG8eutJFXzq2NSG+/9vBCaXMb4DsKHUcA4wpLyZmNlYYCxA586dq7I+ESlDdJTRslE8LRvFH/M8ioudA4XFHCgMhcaBgmIOFoXfFxZTWOQUFBVzsCj0vqi4mIIip7A4NFxY7BSFX4XFTnGxU+ShYXenqBiK3MGdYg+9Dw2G2wDuUOyh9oeGnXC78DCHhsucFhpHyfv/KH3ExkvGfbtNaWW1L7th2aOTEqrnK73agsLMZgJty5h0v7tPC7e5HygEXj7e5bn7eGA8hA49He/8RKT6RUUZDeKiaRCnE+W1WbUFhbufVdF0M7seuAA408s+UbIR6FRquGN4nIiI1KBAbtUMX830M+BCd88rp9mnQHczSzGzOOBK4I2aqlFEREKCuqf/CSAJeNfMFpnZ0wBm1t7MpgO4eyFwBzADWAG86u7LAqpXRCRiBXXVU7dyxm8Czi81PB2YXlN1iYjId6mXMBERqZCCQkREKqSgEBGRCikoRESkQvWy91gz2wZ8dYwfbwlsr8Jy6oJIXGeIzPWOxHWGyFzvo13nLu7eqqwJ9TIojoeZZZbXMVZ9FYnrDJG53pG4zhCZ612V66xDTyIiUiEFhYiIVEhB8V3jgy4gAJG4zhCZ6x2J6wyRud5Vts46RyEiIhXSHoWIiFRIQSEiIhVSUISZ2blmttLMVpvZfUHXU13MrJOZfWBmy81smZn9JDy+uZm9a2arwj+bBV1rVTOzaDNbaGb/Cg+nmNn88DafHO7Ovl4xs6Zm9pqZfWFmK8zspPq+rc3srvDv9lIz+7uZJdTHbW1mz5nZVjNbWmpcmdvWQv4cXv8lZjbgaJaloCD0BQI8CZwH9AauMrPewVZVbQqBe9y9NzAUuD28rvcB77l7d+C98HB98xNCXdYf8ijwv+HejL8B/iuQqqrX48A77t4TSCO0/vV2W5tZB+DHQIa79wGiCT3Lpj5u6xeAcw8bV962PQ/oHn6NBZ46mgUpKEIGA6vdfa27HwQmAaMDrqlauPvX7v5Z+H0uoS+ODoTW98VwsxeBiwIpsJqYWUfge8Cz4WEDzgBeCzepj+vcBBgBTABw94Puvot6vq0JPT6hgZnFAA2Br6mH29rdZwE7Dxtd3rYdDUz0kE+ApmbWrrLLUlCEdAA2lBrOCY+r18wsGegPzAfauPvX4UmbgTZB1VVN/kToqYrF4eEWwK7wA7Kgfm7zFGAb8Hz4kNuzZpZIPd7W7r4R+D2wnlBA7AayqP/b+pDytu1xfccpKCKUmTUCXgfudPc9paeFn2Feb66bNrMLgK3unhV0LTUsBhgAPOXu/YF9HHaYqR5u62aE/npOAdoDiXz38ExEqMptq6AI2Qh0KjXcMTyuXjKzWEIh8bK7/zM8esuhXdHwz61B1VcNhgEXmlk2ocOKZxA6dt80fHgC6uc2zwFy3H1+ePg1QsFRn7f1WcA6d9/m7gXAPwlt//q+rQ8pb9se13ecgiLkU6B7+MqIOEInv94IuKZqET42PwFY4e5/LDXpDWBM+P0YYFpN11Zd3P0X7t7R3ZMJbdv33f0a4APg++Fm9WqdAdx9M7DBzE4MjzoTWE493taEDjkNNbOG4d/1Q+tcr7d1KeVt2zeA68JXPw0Fdpc6RHVEujM7zMzOJ3QcOxp4zt3/J9iKqoeZnQLMBj7nP8frf0noPMWrQGdCXbRf7u6Hnyir88zsNOBed7/AzLoS2sNoDiwErnX3AwGWV+XMLJ3QCfw4YC1wA6E/EOvttjaz3wJXELrCbyFwE6Hj8fVqW5vZ34HTCHUnvgX4NTCVMrZtODSfIHQYLg+4wd0zK70sBYWIiFREh55ERKRCCgoREamQgkJERCqkoBARkQopKEREpEIKCpHDmNne8M9kM7u6iuf9y8OG51Xl/EWqg4JCpHzJwFEFRam7f8vzraBw95OPsiaRGqegECnfI8BwM1sUfsZBtJk9Zmafhvv0vwVCN/GZ2Wwze4PQXcCY2VQzywo/F2FseNwjhHo1XWRmL4fHHdp7sfC8l5rZ52Z2Ral5f1jqmRIvh2+ewswesdBzRZaY2e9r/F9HIsaR/voRiWT3Eb6LGyD8hb/b3QeZWTww18z+HW47AOjj7uvCwzeG74htAHxqZq+7+31mdoe7p5exrEuAdELPjGgZ/sys8LT+QCqwCZgLDDOzFcDFQE93dzNrWrWrLvIf2qMQqbyzCfWXs4hQlyctCD0IBmBBqZAA+LGZLQY+IdQZW3cqdgrwd3cvcvctwEfAoFLzznH3YmARoUNiu4F8YIKZXUKoWwaRaqGgEKk8A37k7unhV4q7H9qj2FfSKNSf1FnASe6eRqhvoYTjWG7pPomKgJjwsxUGE+oR9gLgneOYv0iFFBQi5csFkkoNzwB+GO6mHTPrEX4Q0OGaAN+4e56Z9ST0yNlDCg59/jCzgSvC50FaEXoy3YLyCgs/T6SJu08H7iJ0yEqkWugchUj5lgBF4UNILxB6hkUy8Fn4hPI2yn6k5jvAreHzCCsJHX46ZDywxMw+C3d1fsgU4CRgMaGHzfzM3TeHg6YsScA0M0sgtKdz9zGtoUglqPdYERGpkA49iYhIhRQUIiJSIQWFiIhUSEEhIiIVUlCIiEiFFBQiIlIhBYWIiFTo/wNyy0npQGw/eQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "result = ct.get_result(id, wait=True)\n",
    "result = result.result\n",
    "for i in range(len(result)):\n",
    "    plt.plot(np.array(result[i]).T, label=\"GradientDescentOptimizer\")\n",
    "plt.legend()\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.ylabel(\"Cost\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Investigating Optimizer Performance\n",
    "\n",
    "One of the benefits of organizing your code into a workflow is the ease of rapid prototyping and experimentation. For example, the `optimize_electron` function allows you to modify the initial angles and optimizer used in the optimization process.\n",
    "\n",
    "Pennylane offers a number of different optimizers in addition to the GradientDescentOptimizer that use various methods to navigate the cost landscape. An optimizer will automatically update problem parameters as they minimize the value of the cost function. Below, we examine four different Pennylane optimizers to see which one best minimizes our cost function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizers = [\n",
    "    qml.GradientDescentOptimizer(),\n",
    "    qml.AdagradOptimizer(),\n",
    "    qml.MomentumOptimizer(),\n",
    "    qml.AdamOptimizer(),\n",
    "]\n",
    "id = ct.dispatch(run_exp)(p=1, qubits=2, prob=1.2, optimizers=optimizers, iterations=100)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The below result runs the `run_exp` for each optimizer in our list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "result = ct.get_result(id, wait=True)\n",
    "result = result.result\n",
    "simulators = [\n",
    "    \"GradientDescentOptimizer\",\n",
    "    \"AdagradOptimizer\",\n",
    "    \"MomentumOptimizer\",\n",
    "    \"AdamOptimizer\",\n",
    "]\n",
    "for i in range(len(result)):\n",
    "    plt.plot(np.array(result[i]).T, label=simulators[i])\n",
    "plt.legend()\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.ylabel(\"Cost\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "\n",
    "## The Optimize Workflow\n",
    "\n",
    "In actual quantum computing runs, each iteration in the optimization process is costly both in time and resources - so we might want to monitor our optimization process at each iteration. Unlike the `run_exp` workflow, where optimization done in an electron, the `Optimize` workflow contains the optimization within the lattice itself.\n",
    "The downside of structuring the workflow this way is that it can take much longer if it is sent to actual quantum devices due to queues."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "@ct.lattice\n",
    "def optimize(p=1, qubits=2, prob=0.3, optimizers=[qml.GradientDescentOptimizer()], iterations=10):\n",
    "    compare_optimizers = []\n",
    "    for optimizer in optimizers:\n",
    "        loss_history = []\n",
    "        cost_function, init_angles = initialize_parameters(p=p, qubits=qubits, prob=prob)\n",
    "        params = init_angles\n",
    "        for _ in range(iterations):\n",
    "            optimizer, params, loss = calculate_cost(\n",
    "                cost_function=cost_function, params=params, optimizer=optimizer\n",
    "            )\n",
    "            loss_history.append(loss)\n",
    "        compare_optimizers.append(loss_history)\n",
    "    return compare_optimizers\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can again visualize our workflow from the Covalent UI.\n",
    "\n",
    "![](./assets/optimize_dag.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterations = 20\n",
    "p = 1\n",
    "qubits = 1\n",
    "prob = 0.6\n",
    "optimizers = [\n",
    "    qml.GradientDescentOptimizer(),\n",
    "    qml.AdagradOptimizer(),\n",
    "    qml.MomentumOptimizer(),\n",
    "]\n",
    "id = ct.dispatch(optimize)(\n",
    "    p=p, qubits=qubits, prob=prob, iterations=iterations, optimizers=optimizers\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Comparing Optimizer Results\n",
    "\n",
    "As before, we compare the loss as the number of iterations is increased."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "result = ct.get_result(id, wait=True)\n",
    "result = result.result\n",
    "for i in range(len(result)):\n",
    "    plt.plot(np.array(result[i]).T, label=simulators[i])\n",
    "plt.legend()\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.ylabel(\"Cost\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "\n",
    "# Investigating Angle Optimization\n",
    "\n",
    "In previous steps, we've seen how the choice of optimizer impacts the optimization process, where we've plotted the cost as a function of iterations. But we can also explore how the hyperparameter angles change during optimization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "@ct.lattice\n",
    "def optimize(p=1, qubits=2, prob=0.3, optimizers=[qml.GradientDescentOptimizer()], iterations=10):\n",
    "    compare_optimizers = []\n",
    "    for optimizer in optimizers:\n",
    "        loss_history = []\n",
    "        cost_function, init_angles = initialize_parameters(p=p, qubits=qubits, prob=prob)\n",
    "        params = init_angles\n",
    "        alpha_list = []\n",
    "        beta_list = []\n",
    "        for _ in range(iterations):\n",
    "            optimizer, params, loss = calculate_cost(\n",
    "                cost_function=cost_function, params=params, optimizer=optimizer\n",
    "            )\n",
    "            loss_history.append(loss)\n",
    "            alpha_list.append(params[0])\n",
    "            beta_list.append(params[1])\n",
    "        compare_optimizers.append(loss_history)\n",
    "    return compare_optimizers, alpha_list, beta_list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "result = ct.get_result(id, wait=True)\n",
    "alpha = result.result[1]\n",
    "beta = result.result[2]\n",
    "for i in range(len(alpha)):\n",
    "    plt.scatter(i, alpha[i], color=\"red\")\n",
    "    plt.scatter(i, beta[i], color=\"green\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting the cost vs iterations for a range of different initial angles\n",
    "\n",
    "There are many different ways to implement this, both within and outside the lattice. In this solution, we explore four angle ranges between 0 and $2\\pi$: 0 to $\\frac{\\pi}{2}$, $\\frac{\\pi}{2}$ to $\\pi$, $\\pi$ to $\\frac{3}{2} \\pi$, and $\\frac{3}{2} \\pi$ to $2 \\pi$. This involved making edits to the `get_random_initialization` and `initialize_parameters` functions: in the first case, we modify the range of values used to initialize angles and in the latter case we call the `get_random_initialization` function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "@ct.electron\n",
    "def get_random_initialization(p=1, lower_l=0, higher_l=2 * np.pi):\n",
    "    return np.random.uniform(lower_l, higher_l, (2, p), requires_grad=True)\n",
    "\n",
    "\n",
    "@ct.electron\n",
    "def initialize_parameters(p=1, qubits=2, prob=0.3, lower_l=0, higher_l=2 * np.pi):\n",
    "    cost_h, mixer_h = make_graph(qubits=qubits, prob=prob)\n",
    "    circuit = get_circuit(cost_h, mixer_h)\n",
    "    cost_function = make_cost_function(circuit, cost_h, qubits)\n",
    "    initial_angles = get_random_initialization(p=p, lower_l=lower_l, higher_l=higher_l)\n",
    "    return cost_function, initial_angles\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "@ct.lattice\n",
    "def run_exp(\n",
    "    p=1,\n",
    "    qubits=2,\n",
    "    prob=0.3,\n",
    "    optimizers=[qml.GradientDescentOptimizer()],\n",
    "    iterations=10,\n",
    "    limits=[[0, 2 * np.pi]],\n",
    "):\n",
    "    compare_optimizers = []\n",
    "    tmp = []\n",
    "    for lower_l, higher_l in limits:\n",
    "        cost_function, init_angles = initialize_parameters(\n",
    "            p=p, qubits=qubits, prob=prob, lower_l=lower_l, higher_l=higher_l\n",
    "        )\n",
    "        for optimizer in optimizers:\n",
    "            loss_history = optimize_electron(\n",
    "                cost_function=cost_function,\n",
    "                init_angles=init_angles,\n",
    "                optimizer=optimizer,\n",
    "                iterations=iterations,\n",
    "            )\n",
    "            tmp.append(loss_history)\n",
    "    compare_optimizers.append(tmp)\n",
    "    return compare_optimizers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "limits = [\n",
    "    [0, np.pi / 2],\n",
    "    [np.pi / 2, np.pi],\n",
    "    [np.pi, np.pi * 1.5],\n",
    "    [np.pi * 1.5, 2 * np.pi],\n",
    "]\n",
    "optimizers = [qml.AdamOptimizer()]\n",
    "\n",
    "labels = [\"0 to pi/2\", \"pi/2 to pi\", \"pi to 3pi/2\", \"3pi/2 to 2pi\"]\n",
    "\n",
    "local_result = run_exp(\n",
    "    p=1, qubits=2, prob=1.2, optimizers=optimizers, iterations=100, limits=limits\n",
    ")\n",
    "\n",
    "for i in range(len(local_result[0])):\n",
    "    plt.plot(np.array(local_result[0][i]).T, label=labels[i])\n",
    "plt.legend()\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.ylabel(\"Cost\")\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "qaoa-qa",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "632c03d99b731bab0c715d6441833ac044ad4b793a4055bfe63caff071b24b97"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
